import { getNewCartGoods, findCart, mergeCart, insertCart, deleteCart, updateCart, checkAllCart } from '@/api/cart'

// 购物车状态
export default {
  namespaced: true,
  state: () => {
    return {
      list: []
    }
  },
  // 修改
  mutations: {
    // 设置购物车列表
    setCartList (state, list) {
      state.list = list
    },
    // 修改购物车商品
    updateCart (state, goods) {
      const goodsObj = state.list.find(item => item.skuId === goods.skuId)
      for (const key in goods) {
        // 排除掉无效值 null
        if (goods[key] !== null) {
          goodsObj[key] = goods[key]
        }
      }
    },
    // 删除购物车商品
    deleteCart (state, skuId) {
      // 方案1：通过过滤实现删除
      state.list = state.list.filter(item => item.skuId !== skuId)
      // 方案2：
      // const index = state.list.findIndex(item => item.skuId === skuId)
      // state.list.splice(index, 1)
    },
    // 加入购物车
    insertCart (state, goodsItem) {
      const index = state.list.findIndex(item => item.skuId === goodsItem.skuId)
      if (index === -1) {
        state.list = [goodsItem, ...state.list]
      } else {
        state.list[index].count += goodsItem.count
      }
    }
  },
  // 异步
  actions: {
    // 封装获取购物车列表的请求
    async getAndSetCartList (store) {
      // 获取购物车列表
      const { result } = await findCart()
      // console.log(result)
      store.commit('setCartList', result)
    },
    // 合并本地购物车
    async mergeLocalCart (store) {
      // console.log(11111, store.state.list)
      const data = store.state.list.map(item => ({ skuId: item.skuId, selected: item.selected, count: item.count }))
      // 注意：合并购物车没有返回值
      await mergeCart(data)
      // 调用获取购物车列表
      store.dispatch('getAndSetCartList')
    },
    // 获取购物车列表
    findCartList (store) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 情况1：已登录，调用接口
          // 获取并设置购物车列表
          store.dispatch('getAndSetCartList')
        } else {
          // 未登录也要同步最新商品信息(价格,库存...)
          store.state.list.forEach(async (item) => {
            // 每个商品都要获取最新信息
            const { result } = await getNewCartGoods(item.skuId)
            // console.log(result)
            // skuId 用于查找必传字段，result 是要更新的信息
            store.commit('updateCart', { skuId: item.skuId, ...result })
          })
          resolve('更新成功-本地更新')
        }
      })
    },
    // 更新 SKU 信息 - 删除旧的SKU商品，前添加新的SKU商品
    updateCartSku (store, { oldSkuId, newSku }) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 情况1：已登录，调用接口
          const oldGoods = store.state.list.find(item => item.skuId === oldSkuId)
          // 1. 删除旧商品
          deleteCart([oldGoods.skuId]).then(async () => {
            // 2. 插入新商品 💥 SKUID 使用新的，💥但是数量是使用旧的
            await insertCart({ skuId: newSku.skuId, count: oldGoods.count })
            // 3. 获取并设置列表
            store.dispatch('getAndSetCartList')
            // 状态维护
            resolve('SKU更新成功-接口调用')
          })
        } else {
          // 情况2：未登录，直接添加到本地存储中
          // 1. 获取旧的商品信息
          const oldGoods = store.state.list.find(item => item.skuId === oldSkuId)
          // 2. 删除旧的商品
          store.commit('deleteCart', oldGoods.skuId)
          // 3. 合并一条新的商品信息
          console.log(oldGoods, newSku)
          const newGoods = {
            ...oldGoods,
            skuId: newSku.skuId,
            attrsText: newSku.attrsText,
            // 后面三个都要改字段名
            stock: newSku.inventory,
            nowPrice: newSku.price,
            price: newSku.oldPrice
          }
          // 4. 去插入即可
          store.commit('insertCart', newGoods)
          resolve('更新成功')
        }
      })
    },
    // 批量删除选中商品 + 批量删除失效商品
    batchDeleteCart (store, isInvalid = false) {
      return new Promise((resolve, reject) => {
        // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
        if (store.rootState.user.profile.token) {
          // 情况1：已登录，调用接口
          const ids = store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].map(item => item.skuId)
          deleteCart(ids).then(() => {
            store.dispatch('getAndSetCartList')
            resolve('删除成功-接口调用')
          })
        } else {
          // 情况2：未登录，直接添加到本地存储中
          // console.log('业务1：删除失效商品')
          store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].forEach(item => {
            store.commit('deleteCart', item.skuId)
          })
          resolve('删除成功')
        }
      })
    },
    // 做有效商品的全选&反选
    checkAllCart (store, selected) {
      return new Promise((resolve, reject) => {
        // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
        if (store.rootState.user.profile.token) {
          // 情况1：已登录，调用接口
          const ids = store.getters.validList.map(item => item.skuId)
          // console.log({ ids, selected })
          checkAllCart({ selected, ids }).then(() => {
            store.dispatch('getAndSetCartList')
            resolve('批量更新成功-接口调用')
          })
        } else {
          // 情况2：未登录，直接添加到本地存储中
          store.getters.validList.forEach(item => {
            store.commit('updateCart', { skuId: item.skuId, selected: selected })
          })
          resolve('更新成功')
        }
      })
    },
    // 修改购物车商品
    updateCart (store, goods) {
      return new Promise((resolve, reject) => {
        // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
        if (store.rootState.user.profile.token) {
          // 情况1：已登录，调用接口
          updateCart(goods).then(() => {
            store.dispatch('getAndSetCartList')
            resolve('更新成功-接口调用')
          })
        } else {
          // 情况2：未登录，直接添加到本地存储中
          store.commit('updateCart', goods)
          resolve('更新成功')
        }
      })
    },
    // 删除购物车商品
    deleteCart (store, skuId) {
      return new Promise((resolve, reject) => {
        // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
        if (store.rootState.user.profile.token) {
          // 情况1：已登录，调用接口
          deleteCart([skuId]).then(() => {
            store.dispatch('getAndSetCartList')
            resolve('删除商品成功')
          })
        } else {
          // 情况2：未登录，直接添加到本地存储中
          store.commit('deleteCart', skuId)
          resolve('删除商品成功')
        }
      })
    },
    // 加入购物车
    insertCart (store, goodsItem) {
      return new Promise((resolve, reject) => {
        // console.log(store)
        // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
        if (store.rootState.user.profile.token) {
          // 情况1：已登录，调用接口
          insertCart(goodsItem).then(() => {
            // 加入购物车成功后，直接获取并更新最新列表
            store.dispatch('getAndSetCartList')
            // 调用 resolve 可以让 Promise 对象执行 then 的回调函数
            resolve('加入购物车成功-接口调用')
          })
        } else {
          // 情况2：未登录，直接添加到本地存储中
          store.commit('insertCart', goodsItem)
          resolve('加入购物车成功-本地')
        }
      })
    }
  },
  // 计算属性
  getters: {
    // 是否全选
    isCheckAll (state, getters) {
      return getters.selectedList.length === getters.validList.length && getters.validList.length !== 0
    },
    // 选中商品总金额 - 依赖选中的商品列表
    selectedAmount (state, getters) {
      return getters.selectedList.reduce((sum, item) => sum + item.nowPrice * item.count, 0).toFixed(2)
    },
    // 选中商品件数 - 依赖选中的商品列表
    selectedTotal (state, getters) {
      return getters.selectedList.reduce((sum, item) => sum + item.count, 0)
    },
    // 选中商品列表 - 依赖有效商品列表
    selectedList (state, getters) {
      return getters.validList.filter(item => item.selected)
    },
    // 无效商品列表
    invalidList (state) {
      return state.list.filter(item => !(item.stock > 0 && item.isEffective))
    },
    // 有效商品列表
    validList (state) {
      // 库存大于 0 并且 有效
      return state.list.filter(item => item.stock > 0 && item.isEffective)
    },
    // 有效商品件数
    validTotal (state, getters) {
      return getters.validList.reduce((sum, item) => sum + item.count, 0)
    },
    // 有效商品总金额
    validAmount (state, getters) {
      return getters.validList.reduce((sum, item) => sum + item.count * item.nowPrice, 0).toFixed(2)
    }
  }
}
